#include<iostream>
using namespace std;

// class A
// {
// public:
// 	A(int a = 0)
// 		:_a(a)
// 	{
// 		cout << "A(int a)" << endl;
// 	}
// 	~A()
// 	{
// 		cout << "~A()" << endl;
// 	}
// private:
// 	int _a;
// };


// class Solution {
// public:
// 	int Sum_Solution(int n) {
// 		//...
// 		return n;
// 	}
// };

// int main()
// {
// 	A aa1;
// 	A aa2(1);

// 	// 匿名对象，生命周期只在当前这一行
//     // 这是即用即销毁的对象
// 	A(2);

// 	A aa3(1);

// 	Solution s1;
// 	s1.Sum_Solution(10);

// 	Solution().Sum_Solution(10);

// 	return 0;
// }







// class A
// {
// public:
// 	A(int a = 0)
// 		:_a(a)
// 	{
// 		cout << "A(int a)" << endl;
// 	}

// 	A(int a1, int a2)
// 	{
// 		cout << "A(int a1, int a2)" << endl;
// 	}

// 	A(const A& aa)
// 		:_a(aa._a)
// 	{
// 		cout << "A(const A& aa)" << endl;
// 	}

// 	A& operator=(const A& aa)
// 	{
// 		cout << "A& operator=(const A& aa)" << endl;
// 		if (this != &aa)
// 		{
// 			_a = aa._a;
// 		}
// 		return *this;
// 	}

// 	~A()
// 	{
// 		cout << "~A()" << endl;
// 	}
// private:
// 	int _a;
// };

// void f1(const A& aa)
// {}

// int main()
// {
// 	// 引用传参
// 	A aa1;
// 	f1(aa1);
// 	cout << endl;

// 	f1(A(2));
// 	cout << endl;

// 	f1(2);
// 	cout << endl;

// 	return 0;
// }






//void f1(A aa)
//{}

//int main()
//{
//	// 传值传参
//	A aa1;
//	f1(aa1);
//	cout << endl;
//
//	// 娃哈哈  建议2元，景区有其他价格
//	// 连续一个表达式中，构造+拷贝构造-》优化为直接构造
//	f1(A(2));
//	cout << endl;
//
//	f1(2);
//	cout << endl;
//
//	A aa3 = 3;
//	cout << endl;
//
//	return 0;
//}





// A f2()
// {
// 	A aa;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;
// 	cout << "1111111111" << endl;

// 	return aa;
// }

// int main()
// {
// 	// 连续一个表达式中，拷贝构造 + 拷贝构造 - 》优化为一个拷贝构造
// 	A ret1 = f2();
// 	cout << endl;

// 	// 无法优化，建议尽量不要这样写
// 	A ret2;
// 	ret2 = f2();
// 	cout << endl;

// 	return 0;
// }





// void f2()
// {
// 	// 局部的静态第一个调用时构造初始化
// 	static A aa3;
// }

// // 全局对象，再main函数之前构造
// A aa0;

// int main()
// {
// 	// 后定义先析构
// 	A aa1;
// 	A aa2;

// 	f2();
// 	cout << "1111111111111111111" << endl;
// 	f2();
// 	cout << "1111111111111111111" << endl;

// 	return 0;
// }






//int main()
//{
//	// 栈
//	const int a = 0;
//	int b = 0;
//	cout << &a << endl;
//	cout << &b << endl;
//
//	const char* p = "11111111";
//	cout << (void*)p << endl;
//
//	return 0;
//}





// int main()
// {
// 	// 内置类型
// 	// 除了用法方便，c malloc没什么区别
// 	int* p1 = new int;
// 	int* p2 = new int[10];


// 	// 默认不初始化，但是可以初始化
// 	int* p4 = new int(10);
// 	int* p3 = new int[10]{1,2,3,4};

// 	delete p1;
// 	delete[] p2;
// 	delete[] p3;
// 	delete p4;

// 	return 0;
// }





class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(int a1, int a2)
	{
		cout << "A(int a1, int a2)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};





// int main()
// {
// 	// 自定义类型， new才能调用构造初始化，malloc不再适用
// 	A* p1 = (A*)malloc(sizeof(A));
// 	//p1->_a = 0;
// 	free(p1);

// 	// 开空间/释放空间，还会调用构造和析构
// 	A* p2 = new A;
// 	A* p3 = new A(2);

// 	delete p2;
// 	delete p3;

// 	cout << endl;

// 	//A* p4 = new A[10];
// 	//A aa1(1);
// 	//A aa2(2);
// 	//A aa3(3);
// 	//A* p4 = new A[10]{aa1, aa2, aa3};

// 	A* p4 = new A[10]{ 1,2,3,4,5,{6,7}};
// 	delete[] p4;

// 	return 0;
// }







#include<stack>

// int main()
// {
// 	// new -> operator new -> (malloc) + 构造函数
// 	A* p2 = new A;

// 	// 析构 + operator delete -> (free)
// 	delete p2;

// 	stack<int>* p3 = new stack<int>;
// 	delete p3;

// 	return 0;
// }



// double Division(int a, int b)
// {
// 	// 当b == 0时抛出异常
// 	if (b == 0)
// 		throw "Division by zero condition!";
// 	else
// 		return ((double)a / (double)b);
// }

// void Func()
// {
// 	int len, time;
// 	cin >> len >> time;
// 	cout << Division(len, time) << endl;
// }

// int main()
// {
// 	try 
// 	{
// 		Func();
// 	}
// 	catch(const char* errmsg)
// 	{
// 		cout << errmsg << endl;
// 	}
// 	catch (...)
// 	{
// 		cout << "unkown exception" << endl;
// 	}

// 	return 0;
// }



struct ListNode
{
	ListNode* _next;
	int _val;

	ListNode(int val)
		:_next(nullptr)
		, _val(val)
	{}
};

void func()
{
	// new失败了，抛异常, 不需要再检查返回值
	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(2);
	ListNode* n3 = new ListNode(3);

	int* p1 = new int[100 * 1024 * 1024];
	int* p2 = new int[100 * 1024 * 1024];
	int* p3 = new int[100 * 1024 * 1024];
	int* p4 = new int[100 * 1024 * 1024];
	int* p5 = new int[100 * 1024 * 1024];
	int* p6 = new int[100 * 1024 * 1024];

	n1->_next = n2;
	n2->_next = n3;

	delete n1;
	delete n2;
	delete n3;
}

int main()
{
	try
	{
		func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}